COMMENT ⊗   VALID 00011 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002	@device(LPT)
C00003 00003	@BEGIN[MRSEntry]@Name(pdt-stash)
C00007 00004	@BEGIN[MRSEntry]@Name(pdt-unstash)
C00012 00005	@BEGIN[MRSEntry]@Name(pdt-ulookup)
C00018 00006	@BEGIN[MRSEntry]@Name(pdt-lookup)
C00024 00007	@BEGIN[MRSEntry]@Name(pdt-indb)
C00030 00008	@BEGIN[MRSEntry]@Name(pdt-lookupval)
C00036 00009	@BEGIN[MRSEntry]@Name(sp-stash)
C00039 00010	@BEGIN[Example]  	Other things which I should discuss...
C00042 00011	@BEGIN[Comment]		Outtakes
C00044 ENDMK
C⊗;
@device(LPT)
@libraryfile(dictionary)

@Comment{
			***** NOTE *****
	 THE MOST CURRENT FILE IS <SAIL>RPNPRC.MSS[1,rdg];
    this SCORE file which is unofficial, and not necessarily up to date!!!

This RePresentatioN PRoCedure file contains descriptions of the
actual lisp procedures used to implement the various methods associated
with the different representations.

It belongs in the Representation Methods Section of the MRS Dictionary.
}

---- No, as of 1-Oct, each procedure takes a propositional expression,
NOT a symbol.
@BEGIN[MRSEntry]@Name(pdt-stash)
@Brief(Stashes a proposition, using the @T[PDT] representation.)

@Usage{@T{(pdt-stash} <prop>@T{)}}

@Type(Lisp Procedure)

@Descript{
@T[pdt-stash] stores its single argument,
the propositional expression, <prop>,
using the @T[PDT] representation scheme.
That is, this <prop> is stored in the discrimination net 
associated with the currently active theory;
and can later be indexed by the full proposition.

Whenever a proposition has the representation @T[PDT],
(i.e., whenever @T[(REPN <prop> PDT)] -- see @MRSREF[REPN] entry,)
(@T[$stash] <prop>) will invoke (@T[pdt-stash] <prop>).
Note that, as PDT is the default representation,
by default every proposition will be stashed using @T[pdt-stash].
}

@SeeAlso[@MRSREF{PDT}, @MRSREFT{$stash}]

@Warnings{
(See the warning in @MRSREF[PDT].)
}

@Diagnostics{
This procedure should always return the proposition it was passed.
The value @T[NIL] indicates some error in the stashing process --
and the proposition may not have been stashed.}

@History(RDG, 9 September 1982, created)

@Interactions{
@T[$stash] will invoke @T[pdt-stash] whenever 
its argument (a proposition) uses the @T[PDT] representation.
As PDT is the default representation,
@T[pdt-stash] is the default stashing procedure.
}

@Examples{
We will work through what happens when @T[($stash '(LOVES George Mary))] is typed,
when @T[(REPN ↑(LOVES $A $B) PDT)] and the current theory is @T[LOVING].
That top level @T[$stash], after going through the KB, will call
@T[(pdt-stash ↑(LOVES George Mary))].
This will find the PDT discrimination net associated with this @T[LOVING] theory,
and store this fact in that data structure.
(This process is elaborated in the @i[Examples] part of
@MRSREF[Discrimination Net].)
}

@sourcefile(DREPN.CL)

@keywords(@MRSIndex[store], @MRSIndex[representation], 
@MRSIndex[discrimination net])
@END[MRSEntry]
@BEGIN[MRSEntry]@Name(pdt-unstash)
@Brief(Unstashes a proposition, using the @T[PDT] representation.)

@Usage{@T{(pdt-unstash} <prop>@T{)}}

@Type(Lisp Procedure)

@Descript{
@T[pdt-unstash]'s single argument, <prop>, is a proposition,
which will be removed 
from the @T[PDT] discrimination net associated with the currently active theory.
(See @i[Warning] below.)

Whenever a proposition has the representation @T[PDT],
(i.e., whenever @T[(REPN <prop> PDT)] -- see @MRSREF[REPN] entry,)
(@T[$unstash] <prop>) will invoke (@T[pdt-stash] <prop>).
Note that, as PDT is the default representation,
by default every proposition will be unstashed using @T[pdt-unstash].
}

@SeeAlso[@MRSREF{PDT}, @MRSREFT{$unstash}]

@Warnings{
First, see the warnings mentioned in @MRSREF[PDT].
Second, note that if <prop> is present on some other theory, 
or had been stored using some other representation,
this command will have no effect, and will return @T[NIL].
That is, @T[(pdt-unstash] <prop>@T[)] has any effect only
when this <prop> had been
@T[pdt-stash]ed, onto the current theory.
}

@Diagnostics{
This procedure will return the proposition it was passed,
if it was successful in unstashing that proposition.
Otherwise the value @T[NIL] will be returned.
There are several things this can mean:
The proposition (denoted by) <prop>
@BEGIN[ITEMIZE]
is present, but not on the current @T[THEORY]. 
Here that <prop> will still be present.

is not present, not on any current theory.
Here this unstashed <prop> will remain inactive.

may or may not be present, but there was some error in the unstashing process --
and the proposition may or may not still be present.
@END[ITEMIZE]
}

@History(RDG, 9 September 1982, created)

@Interactions{
@T[$unstash] will invoke @T[pdt-unstash] whenever 
its argument (a proposition) uses the @T[PDT] representation.
As PDT is the default representation,
@T[pdt-unstash] is the default stashing procedure.
}

@Examples{
We will work through what happens when @T[($unstash '(LOVES George Mary))] is typed,
when @T[(REPN ↑(LOVES $A $B) PDT)],
and this @T[(LOVES George Mary)] had been stashed when the
current theory was @T[LOVING].
That top level @T[$unstash], after going through the KB, will call
@T[(pdt-unstash ↑(LOVES George Mary))].
This will find the PDT discrimination net associated with this @T[LOVING] theory,
and (locate and then) remove this fact in that data structure.
(This process is elaborated in the @i[Examples] part of 
@MRSREF[Discrimination Net].)

Note if the current theory is reset, to, say, @T[SuperLOVING], this @T[$unstash]
will have no effect -- even though @T[($lookup '(LOVES George Mary))]
may still return @T[(T)]. 
(Assuming @T[(INCLUDES SuperLOVING LOVING)] is true.)
}

@sourcefile(DREPN.CL)

@keywords(@MRSIndex[remove], @MRSIndex[representation], 
@MRSIndex[discrimination net])
@END[MRSEntry]
@BEGIN[MRSEntry]@Name(pdt-ulookup)
@Brief(Searches for a proposition which unifies with its argument,
using the @T[PDT] representation.)

@Usage{@T{(pdt-ulookup} <prop>@T{)}}

@Type(Lisp Procedure)

@Descript{
This call returns a list of binding lists,
each corresponding to a currently present proposition which
is stored in the PDT discrimination net
associated with some currently active theory,
and which unifies with <prop>.

Whenever a proposition has the representation @T[PDT],
(i.e., whenever @T[(REPN <prop> PDT)] -- see @MRSREF[REPN] entry,)
(@T[$ulookupn] <proposition> <num>) will call (@T[pdt-ulookup] <prop>).

Note that, as PDT is the default representation,
by default every proposition will be unify-look-up-ed using @T[pdt-ulookup].

This @T[pdt-ulookup] is more general than @T[pdt-lookup] and @T[pdt-indb],
which have a more constrained matching criteria.
(They all consider the same set of set of propositions --
those found in the active PDT discrimination nets.)
The @i[Interactions] part of @MRSENTRY[Representation]
elucidates this distinction.)

All three above procedures "know" about the QB --
hence they each return the correct number of binding lists,
and eliminate duplicates when appropriate.
}

@SeeAlso[@MRSREF{PDT}, @MRSREFT{$ulookup}]

@Warnings{
(See the warnings mentioned in @MRSREF[PDT].)
}

@Diagnostics{
(N/A)
}

@History(RDG, 18 September 1982, created)


@Interactions{
@T[$ulookupn] will invoke @T[pdt-ulookup] whenever 
its argument (a proposition) uses the @T[PDT] representation.
(As both (@T[$ulookup] <proposition>) and (@T[$ulookups] <proposition>)
go through @T[$ulookupn], they too will use @T[pdt-ulookup].)
As PDT is the default representation,
@T[pdt-ulookup] is the default unify-look-up-ing procedure.
}

@Examples{
We will work through what happens when
@T[($ulookup '(LOVES George $X))] is typed,
when @T[(REPN ↑(LOVES $A $B) PDT)],
and this @T[(LOVES George Mary)] had been stashed
when the current theory was @T[LOVING].
That top level @T[$ulookup] call,
after going through a pre-parser and the QB, will call
@T[(pdt-ulookup ↑(LOVES George $X))],
and also indicate that exactly one answer is desired.
This will search through the PDT discrimination nets associated with
all of the active theories.
When the @T[LOVING] theory is reached,
it will search that data structure 
(in which this fact had been stored,)
and find it there.  
(@MRSREF[Discrimination Net] elaborates this process.)
In this case, the @T[pdt-ulookup] would return @T[( (T ($X . Mary)) )] 
-- that is, a list consisting of one binding list.
<<<Question - how did it know to return but one of these?>>

Two final notes:@*
First, the call @T[($ulookupn '(LOVES George $X) 4)] would also have
gone through @T[pdt-ulookup], but here would have returned a list of
(up to) four bindings for this @T[$X] variable.
Second, imagine that this @T[(LOVES George Mary)] had been stashed
in some other representation.@FOOT[
This could happen if the value of of the term @T<(REPN ↑(LOVES $A $B))>
was not been @T[PDT] when this
@T[(LOVES George Mary)] proposition was stashed...]
Then this @T[pdt-ulookup] call would NOT have found it.
}

@sourcefile(DREPN.CL)

@keywords(@MRSIndex[retrieve], @MRSIndex[unify], @MRSIndex[representation], 
@MRSIndex[discrimination net])
@END[MRSEntry]
@BEGIN[MRSEntry]@Name(pdt-lookup)
@Brief(Searches for a proposition which matches its argument,
using the @T[PDT] representation.)

@Usage{@T{(pdt-lookup} <prop>@T{)}}

@Type(Lisp Procedure)

@Descript{
This call returns a list of binding lists,
each corresponding to a currently present proposition which
is stored in the PDT discrimination net
associated with some currently active theory,
and which matches this <prop>.

Whenever a proposition has the representation @T[PDT],
(i.e., whenever @T[(REPN <prop> PDT)] -- see @MRSREF[REPN] entry,)
(@T[$lookupn] <proposition> <num>) will call (@T[pdt-lookup] <prop>).

Note that, as PDT is the default representation,
by default every proposition will be matched using this @T[pdt-lookup].

This @T[pdt-lookup] procedure is more general than @T[pdt-indb],
but less general than @T[pdt-ulookup],
in terms of matching criteria.
(They all consider the same set of set of propositions --
those found in the active PDT discrimination nets.)
The @i[Interactions] part of @MRSENTRY[Representation]
elucidates this distinction.)

All three above procedures "know" about the QB --
hence they each return the correct number of binding lists,
and eliminate duplicates when appropriate.
}

@SeeAlso[@MRSREF{PDT}, @MRSREFT{$lookup}]

@Warnings{
(See the warnings mentioned in @MRSREF[PDT].)
}

@Diagnostics{
(N/A)
}

@History(RDG, 18 September 1982, created)


@Interactions{
@T[$lookupn] will invoke @T[pdt-lookup] whenever 
its argument (a proposition) uses the @T[PDT] representation.
(As both (@T[$lookup] <proposition>) and (@T[$lookups] <proposition>)
go through @T[$lookupn], they too will use @T[pdt-lookup].)
As PDT is the default representation,
@T[pdt-ulookup] is the default unify-look-up-ing procedure.
}

@Examples{
We will work through what happens when
@T[($lookup '(LOVES George $X))] is typed,
when @T[(REPN ↑(LOVES $A $B) PDT)],
and this @T[(LOVES George Mary)] had been stashed
when the current theory was @T[LOVING].
That top level @T[$lookup] call,
after going through a pre-parser and the QB, will call
@T[(pdt-lookup ↑(LOVES George $X))],
and also indicate that exactly one answer is desired.
This will search the PDT discrimination nets associated with
all of the active theories.
When the @T[LOVING] theory is reached,
it will search that data structure
(in which this fact had been stored),
and find it there.  
(@MRSREF[Discrimination Net] elaborates this process.)
In this case, the @T[pdt-lookup] would return @T[( (T ($X . Mary)) )] 
-- that is, a list consisting of one binding list.
<<<Question - how did it know to return but one of these?>>

Two final notes:@*
First, the call @T[($lookupn '(LOVES George $X) 4)] would also have
gone through @T[pdt-lookup], but here would have returned a list of
(up to) four bindings for this @T[$X] variable.
Second, imagine that this @T[(LOVES George Mary)] had been stashed
in some other representation.@FOOT[
This could happen if the value of of the term @T<(REPN ↑(LOVES $A $B))>
was not been @T[PDT] when this
@T[(LOVES George Mary)] proposition was stashed...]
Then this @T[pdt-lookup] call would NOT have found it.
}

@sourcefile(DREPN.CL)

@keywords(@MRSIndex[retrieve], @MRSIndex[match], @MRSIndex[instantiate],
@MRSIndex[representation], @MRSIndex[discrimination net])
@END[MRSEntry]
@BEGIN[MRSEntry]@Name(pdt-indb)
@Brief(Checks if its argument is in the data base,
using the @T[PDT] representation.)

@Usage{@T{(pdt-indb} <prop>@T{)}}

@Type(Lisp Procedure)

@Descript{
This call returns a list of (at most one) binding lists,
which indicates if <prop> is stored in the PDT discrimination net
associated with some currently active theory.
(The binding list only tells renaming of variables --
see @MRSREF[Same Propsition].)

Whenever a proposition has the representation @T[PDT],
(i.e., whenever @T[(REPN <prop> PDT)] -- see @MRSREF[REPN] entry,)
(@T[$indbn] <proposition> <num>) will call (@T[pdt-indb] <prop>).
(Note that a value <num> greater than one is not meaningful,
as a proposition can be stored at most once in a data base.
<<<ANDY - is that true?>>> )

Note that, as PDT is the default representation,
by default every proposition will be found using this @T[pdt-indb].

This @T[pdt-indb] procedure is less general than either 
@T[pdt-ulookup] or @T[pdt-lookup],
in terms of matching criteria.
(They all consider the same set of set of propositions --
those found in the active PDT discrimination nets.)
The @i[Interactions] part of @MRSENTRY[Representation]
elucidates this distinction.)

All three above procedures "know" about the QB --
hence they each return the correct number of binding lists,
and eliminate duplicates when appropriate.
}

@SeeAlso[@MRSREF{PDT}, @MRSREFT{$indb}]

@Warnings{
(See the warnings mentioned in @MRSREF[PDT].)
}

@Diagnostics{
(N/A)
}

@History(RDG, 18 September 1982, created)

@Interactions{
@T[$indbn] will invoke @T[pdt-indb] whenever 
its argument (a proposition) uses the @T[PDT] representation.
(As (@T[$indb1] <proposition>)
goes through @T[$indbn], they too will use @T[pdt-indb].)
As PDT is the default representation,
@T[pdt-indb] is the default proposition finding procedure.
}

@Examples{
We will work through what happens when
@T[($indb '(LOVES George $X))] is typed,
when @T[(REPN ↑(LOVES $A $B) PDT)],
and this @T[(LOVES George $Y)] had been stashed
when the current theory was @T[LOVING].
That top level @T[$indb] call,
after going through a pre-parser and the QB, will call
@T[(pdt-indb ↑(LOVES George $X))],
and also indicate that exactly one answer is desired.
This will search the PDT discrimination nets associated with
all of the active theories.
When the @T[LOVING] theory is reached,
it will search that data structure
(in which this fact had been stored,)
and find it there.  
(@MRSREF[Discrimination Net] elaborates this process.)
In this case, the @T[pdt-indb] would return @T[( (T ($X . $Y)) )] 
-- that is, a list consisting of one binding list.
<<<Question - how did it know to return but one of these?>>

Realize that, unlike @T[pdt-lookup], this call would have returned
@T[NIL] if @T[(LOVES George Mary)] had been stored rather than
@T[(LOVES George $Y)] 
-- these @T[---INDB---] routines only check if some specific proposition
is stored, and does no variable instantiation.

Two final notes:@*
First, the call @T[($indbn '(LOVES George $X) 1)] would also have
gone through @T[pdt-indb], but here would have returned a list of
(up to) one binding for this @T[$X] variable.
Second, realize that had @T[(LOVES George $Y)] been stashed
in some other representation,@FOOT[
Which would happen if the value of of the term @T<(REPN ↑(LOVES $a $b))>
had not been @T[PDT] when this
@T[(LOVES George $Y)] proposition was stashed...]
this @T[pdt-indb] call would NOT have found it.
}

@sourcefile(DREPN.CL)

@keywords(@MRSIndex[retrieve], @MRSIndex[find], @MRSIndex[representation], 
@MRSIndex[discrimination net])
@END[MRSEntry]
@BEGIN[MRSEntry]@Name(pdt-lookupval)
@Brief(Determines the value of the term given,
using the @T[PDT] representation.)

@Usage{@T{(pdt-lookupval} <term>@T{)}}

@Type(Lisp Procedure)

@Descript{
<<HERE - this procedure still has to be written. >>
This call returns a list of values
each corresponding to a currently present proposition which
is stored in the PDT discrimination net
associated with some currently active theory,
and which matches this <prop>.

Whenever a proposition has the representation @T[PDT],
(i.e., whenever @T[(REPN <prop> PDT)] -- see @MRSREF[REPN] entry,)
(@T[$lookupvalvaln] <term> <num>) will call (@T[pdt-lookupval] <term>).

Note that, as PDT is the default representation,
by default every proposition will be matched using this @T[pdt-lookupval].

This @T[pdt-lookupval] procedure is more general than @T[pdt-indb],
but less general than @T[pdt-ulookupval],
in terms of matching criteria.
(They all consider the same set of set of propositions --
those found in the active PDT discrimination nets.)
The @i[Interactions] part of @MRSENTRY[Representation]
elucidates this distinction.)

All three above procedures "know" about the QB --
hence they each return the correct number of binding lists,
and eliminate duplicates when appropriate.
}

@SeeAlso[@MRSREF{PDT}, @MRSREFT{$lookupval}]

@Warnings{
(See the warnings mentioned in @MRSREF[PDT].)
}

@Diagnostics{
(N/A)
}

@History(RDG, 18 September 1982, created)


@Interactions{
@T[$lookupvaln] will invoke @T[pdt-lookupval] whenever 
its argument (a proposition) uses the @T[PDT] representation.
(As both (@T[$lookupval] <proposition>) and (@T[$lookupvals] <proposition>)
go through @T[$lookupvaln], they too will use @T[pdt-lookupval].)
As PDT is the default representation,
@T[pdt-ulookupval] is the default unify-look-up-ing procedure.
}

@Examples{
We will work through what happens when
@T[($lookupval '(LOVES George $X))] is typed,
when @T[(REPN ↑(LOVES $A $b) PDT)],
and this @T[(LOVES George Mary)] had been stashed
when the current theory was @T[LOVING].
That top level @T[$LOOKUPVAL] call,
after going through a pre-parser and the QB, will call
@T[(pdt-lookupval ↑(LOVES George $X))],
and also indicate that exactly one answer is desired.
This will search the PDT discrimination nets associated with
all of the active theories.
When the @T[LOVING] theory is reached,
it will search that data structure
(in which this fact had been stored),
and find it there.  
(@MRSREF[Discrimination Net] elaborates this process.)
In this case, the @T[pdt-lookupval] would return @T[( (T ($X . Mary)) )] 
-- that is, a list consisting of one binding list.
<<<Question - how did it know to return but one of these?>>

Two final notes:@*
First, the call @T[($LOOKUPVALN '(LOVES George $X) 4)] would also have
gone through @T[pdt-lookupval], but here would have returned a list of
(up to) four bindings for this @T[$X] variable.
Second, imagine that this @T[(LOVES George Mary)] had been stashed
in some other Representation.@FOOT[
This could happenif the valua oF of the term @T<(REPN ↑(LOVES $A $B))>
was not been @T[PDT] when this
@T[(LOVES George Mary)] proposition was stashed...]
Then this @T[pdt-lookupval] call would NOT have found it.
}

@sourcefile(DREPN.CL)

@keywords(@MRSIndex[retrieve], @MRSIndex[term],
@MRSIndex[representation], @MRSIndex[discRimination net])
@END[MBSEntry]
@BEGIN[MRSEntry]@Name(sp-stash)
@Brief(Stashes a proposition, using the @T[SP] representation.)

@Usage{@T{(sp-stash} <prop>@T{)}}

@Type(Lisp Procedure)

@Descript{
@T[sp-stash]'s single argument, <prop>, is a proposition,
which it stores using the @T[SP] representation scheme.
<<here>>
That is, the proposition associated with <prop>, 
@T[(Prop Obj Val)], will be stored on @T[Obj]'s property list,
by storing the value @T[Val] on its @T[Prop] property.
}

@SeeAlso[@MRSREF{SP}, @MRSREFT{$STASH}]

@Warnings{
(See the warning in @MRSREF[SP].)
}

@Warnings{
(See the warning mentioned in the @T[SP] entry.)
}

@Diagnostics{
This procedure should always return the proposition it was passed.
The value @T[NIL] indicates some error in the stashing process --
and the proposition may not have been stashed.}

@History(RDG, 9 September 1982, created)

@Interactions{
Whenever a proposition has the representation @T[SP],
(i.e., whenever @T[(REPN <prop> SP)] -- see @MRSREF[REPN] entry,)
(@T[$STASH] <proposition>) will call (@T[sp-stash] <prop>).
}

@Examples{
We will work through what happens when @T[($STASH '(LOVES George Mary))] is typed,
when @T[(REPN ↑(LOVES $A $B) SP)] 
(independent of the current theory).
That top level @T[$STASH], after going through the KB, will call
@T[(sp-stash ↑(LOVES George Mary))].
This will put the value @T[Mary] on the @T[LOVES] property of @T[George]'s
property list.
}

@sourcefile(SPREPN)

@keywords(@MRSIndex[store], @MRSIndex[representation], 
@MRSIndex[discrimination net])
@END[MRSEntry]
@BEGIN[Example]  	Other things which I should discuss...

Andy: Let's call the file DREPN.CL, rather than simply REPN.CL,
as it currently only handles the _D_ representations...

General comment which belongs on $STASH, or STASH -
that (STASH <prop>) will probably do nothing
(ie not stash this <prop>) if this <prop> is already present --
i.e. in another theory, or even in same theory, under different rep'n.

--- what about SPT, MPT ---
pdt-lookupval,
pdg-stash pdg-unstash pdg-ulookup pdg-lookup pdg-indb pdg-lookupval
sp-stash  sp-unstash  sp-ulookup  sp-lookup  sp-indb  sp-lookupval
mp-stash  mp-unstash  mp-ulookup  mp-lookup  mp-indb  mp-lookupval

<<< This goes in the Internals manual: >>>

@T[@i<repn>-ULOOKUP] can be used when things like number of solutions
expected, and acceptance of duplicate entries are important.
There is also a @T[@i<repn>-ULOOKUPS] procedure which simply
returns returns all binding lists possible.
@T[@i<repn>-ULOOKUP1] will return a single binding list, the first
one found for this proposition symbol.

-----
Dave says NOT to include:

	pdt-ulookup1 pdt-ulookups
$pdt-stash -- preparses, and takes proposition expression (not symbol)
↑pdt-stash -- takes proposition expression
↑pdt-ulookup1 -- takes proposition expression
↑pdt-ulookups -- takes proposition expression
	pdg-ulookup1 pdg-ulookups
	sp-ulookup1 sp-ulookups
	mp-ulookup1 mp-ulookups

@END[Example]
@BEGIN[Comment]		Outtakes
@T[@i<repn>-LOOKUPS] and @T[@i<repn>-LOOKUP1] correspond to 
@T[@i<repn>-LOOKUP] in the same way
@T[@i<repn>-ULOOKUPS] and @T[@i<repn>-ULOOKUP1] correspond to 
@T[@i<repn>-ULOOKUP];
simiarly @T[@i<repn>-INDB1] corresponds to @T[@i<repn>-INDB].

-------

@T[pdt-lookup1] and @T[pdt-lookups], on the other hand, perform the same
basic retrieval steps which @T[pdt-lookup] performs,
but return exactly one binding list, or all possible binding lists, respectively.

Finally there are two other related procedures, included only
because this @T[PDT] representation is so prevalent.
@T[↑pdt-lookup1] is just like @T[pdt-lookup1],
but it takes a propositional expression rather than a 
propositional symbol;
@T[↑pdt-lookups] bares the same relation to @T[pdt-lookups].

@END[Comment]